package com.gxa.pingan.service.impl;

import com.gxa.pingan.common.ExceptionCode;
import com.gxa.pingan.exception.BusinessException;
import com.gxa.pingan.mapper.OrderMapper;
import com.gxa.pingan.pojo.*;
import com.gxa.pingan.service.OrderService;
import com.gxa.pingan.utils.CastListUtil;
import com.gxa.pingan.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 订单业务层的具体实现
 *
 * @author YXQ
 * @date 2021/10/25 19:15
 */
@Service(value = "orderService")
@Transactional(rollbackFor = {Throwable.class})
public class OrderServiceImpl implements OrderService {
    @Autowired
    OrderMapper orderMapper = null;

    @Override
    public void addBaseOrder(Map<String, Object> map, HttpServletRequest request) throws BusinessException, IOException {
        System.out.println("前端数据");
        System.out.println(map);
        // 验证手机号
        Object o = map.get("phone");
        if (o != null){
            String phone = o.toString();
            if (!StringUtils.isPhoneNumber(phone)){
                throw new BusinessException(ExceptionCode.PHONE_ERROR);
            }
        }
        // 处理时间pickUpTime
        // 下面这行行代码可以代替这行下面的三行
        // map.putIfAbsent("pickUpTime", null);
        Object pickUpTime1 = map.get("pickUpTime");
        if (pickUpTime1 != null) {
            String s = pickUpTime1.toString();
            // 排除时间是""
            if (!StringUtils.isEmpty(s)){
                String suffix = " 00:00:00";
                String pickUpTime = s + suffix;
                map.put("pickUpTime",pickUpTime);
            }else {
                map.put("pickUpTime",null);
            }
        }else {
            map.put("pickUpTime",null);
        }
        // 处理时间obtainTime
        Object obtainTime1 = map.get("obtainTime");
        if (obtainTime1 != null) {
            String s = obtainTime1.toString();
            // 排除时间是""
            if (!StringUtils.isEmpty(s)){
                String suffix = " 00:00:00";
                String obtainTime = s + suffix;
                map.put("obtainTime",obtainTime);
            }else {
                map.put("obtainTime",null);
            }
        }else {
            map.put("obtainTime",null);
        }
        // 向order表中添加基本表
        orderMapper.addBaseOrder(map);
        // 先判断图片是否为空,不为空时向图片表中添加数据
        Object img = map.get("img");
        // 将图片数组存入list中,之后遍历list循环添加到数据库中
        List<String> list = CastListUtil.castList(img, String.class);
        // 如果用户上传文件之后,又点击了删除之类操作,或者直接取消了添加,需要对上传的图片进行处理
        // 上传的文件都在临时目录如果没有发现img字段,就不需要添加到数据库以及添加到uploadImg中
        if (list.size() != 0) {
            // 添加基本表之后获取到添加之后的id主键(通过selectKey然后存入map中的id是一个Map)
            Map idMap = (Map) map.get("idMap");
            // 从idMap中获取主键的字符串,然后转化成Long类型后存入Map,再添加到数据表OrderImg中
            String idString = idMap.get("LAST_INSERT_ID()").toString();
            // 获取到主键id
            Long id = Long.valueOf(idString);
            // 声明一个订单图片对象方便后续添加
            OrderImg orderImg = new OrderImg();
            // 遍历图片数组
            for (String s : list) {
                // 如果用户上传文件之后,又点击了删除之类操作,或者直接取消了添加,需要对上传的图片进行处理
                // 这里的逻辑是
                // 1.上传的地址是临时目录
                // 2.在执行添加之后将图片从临时目录拷贝到uploadImg中
                // 3.临时目录会定期清理
                // 现在只完成1和2,临时目录的定时清理在springBoot再使用
                // 将图片从临时目录拷贝到uploadImg中
                // 开始敲代码
                // 由字符串截取文件名由split分割成字符数组
                String[] split = s.split("/");
                // 取字符数组最后一个元素即是文件名
                String fileName = split[split.length - 1];
                // 获取文件根目录
                String path = request.getServletContext().getRealPath("/");
                // 拼接出新的文件的相对路径
                String newFilePath = "/images/uploadImg/"+fileName;
                // 构建两个文件对象--临时和新的文件
                File tempFile = new File(path+s);
                File newFile = new File(path+newFilePath);
                try(InputStream input = new FileInputStream(tempFile);
                    OutputStream output = new FileOutputStream(newFile)) {
                    byte[] buf = new byte[1024];
                    int bytesRead;
                    while ((bytesRead = input.read(buf)) != -1) {
                        output.write(buf, 0, bytesRead);
                    }
                }
                // 将图片信息(1.关联订单的id 2.图片在uploadImg中的路径)存入对象中
                orderImg.setOid(id);
                orderImg.setImg(newFilePath);
                // 调用添加的核心操作
                orderMapper.addOrderImg(orderImg);
            }
        }
    }

    @Override
    public void addImportOrder(OrderVo orderVo) throws BusinessException {
        String orderNum = orderVo.getOrderNum();
        Order orderAll = getOrderAll(orderNum);
        if (orderAll != null) {
            throw new BusinessException(ExceptionCode.ORDER_ALREADY_EXIT);
        }
        orderMapper.addImportOrder(orderVo);
        // 添加之后获取添加之后的主键
        Long id = orderVo.getId();
        // 判断是否需要向OrderOther表中添加字段
        String repairParts = orderVo.getRepairParts();
        if (!StringUtils.isEmpty(repairParts)){
            // 构建需要添加的对象
            OrderOther orderOther = new OrderOther();
            // 向对象中添加字段
            orderOther.setOid(id);
            orderOther.setRepairParts(repairParts);
            // 添加到数据库中
            orderMapper.addOrderOther(orderOther);
        }
        Long amountPayByCustomer = orderVo.getAmountPayByCustomer();
        if ( amountPayByCustomer != null){
            // 构建需要添加的对象
            OrderPay orderPay = new OrderPay();
            // 向对象中添加字段
            orderPay.setOid(id);
            orderPay.setAmountPayByCustomer(amountPayByCustomer);
            // 添加到数据库中
            orderMapper.addOrderPay(orderPay);
        }
    }

    @Override
    public List<City> getAreaList() throws BusinessException {
        // 调用获取 区域 列表
        List<City> areaList = orderMapper.getAreaList();
        if (areaList.size() == 0) {
            // 列表长度为0时给前端提示信息
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        return areaList;
    }

    @Override
    public List<Driver> getDriverList(String areaName) throws BusinessException {
        // 调用获取 司机 列表
        List<Driver> driverList = orderMapper.getDriverList(areaName);
        if (driverList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        return driverList;
    }

    @Override
    public List<Shop> getShopList(String areaName, Integer storesType) throws BusinessException {
        // 调用获取 店铺 列表
        List<Shop> shopList = orderMapper.getShopList(areaName, storesType);
        if (shopList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        return shopList;
    }

    @Override
    public List<Message> getOrderTypeList() throws BusinessException {
        // 调用获取 信息 列表--这个里面是带有空的
        List<Message> orderTypeList = orderMapper.getOrderTypeList();
        if (orderTypeList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        // 建一个新的List存放上面List中不为空的全部数据
        List<Message> orderTypeList1 = new ArrayList<>();
        for (Message message : orderTypeList) {
            if (message.getOrderType() != null){
                orderTypeList1.add(message);
            }
        }
        return orderTypeList1;
    }

    @Override
    public List<Message> getTypeList() throws BusinessException {
        // 调用获取 信息 列表--这个里面是带有空的
        List<Message> typeList = orderMapper.getTypeList();
        if (typeList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        // 建一个新的List存放上面List中不为空的全部数据
        List<Message> typeList1 = new ArrayList<>();
        for (Message message : typeList) {
            if (message.getType() != null){
                typeList1.add(message);
            }
        }
        return typeList1;
    }

    @Override
    public List<Message> getOrderSourceList() throws BusinessException {
        // 调用获取 信息 列表
        List<Message> orderSourceList = orderMapper.getOrderSourceList();
        if (orderSourceList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        // 建一个新的List存放上面List中不为空的全部数据
        List<Message> orderSourceList1 = new ArrayList<>();
        for (Message message : orderSourceList) {
            if (message.getOrderSource() != null){
                orderSourceList1.add(message);
            }
        }
        return orderSourceList1;
    }

    @Override
    public List<Order> getOrderList(Map<String, Object> map) throws BusinessException {
        // 转化时间格式的字符串
        // 获取起始时间字符串的值
        String from = (String) map.get("from");
        // 获取终止时间字符串的值
        String to = (String) map.get("to");
        // 给字符串加上00:00:00
        String suffix = " 00:00:00";
        // 判断起始时间的字符串是否为空
        if (!StringUtils.isEmpty(from)) {
            from = from + suffix;
            // 不为空时转化字符串为Timestamp格式
            Timestamp fromTime = Timestamp.valueOf(from);
            // 将新的timestamp格式的数据放入map中
            map.put("from", fromTime);
        } else {
            map.put("from", null);
        }
        // 判断终止时间的字符串是否为空
        if (!StringUtils.isEmpty(to)) {
            to = to + suffix;
            // 不为空时转化字符串为Timestamp格式
            Timestamp toTime = Timestamp.valueOf(to);
            // 将新的timestamp格式的数据放入map中
            map.put("to", toTime);
        } else {
            map.put("to", null);
        }
        // 处理分页--当前端传递的消息中size==0时,表示全查询
        // limit (page - 1)*size,size
        // 获取map中的分页信息
        String page = map.get("page").toString();
        //---------------
        String size = map.get("size").toString();
        // 如果map中page和size为空,则给page和size给予默认值
        int page1 = 1;
        // size为0时默认处理成不带分页的查询
        int size1 = 0;
        // 不为空时为page和size赋值
        if (page != null && size != null) {
            page1 = Integer.parseInt(page);
            size1 = Integer.parseInt(size);
        }
        // 把页数转化为参数需要的偏移量
        page1 = (page1 - 1) * size1;
        // 将处理之后的数据放入map中
        map.put("page", page1);
        map.put("size", size1);
        // 调用获取 订单 列表
        List<Order> orderList = orderMapper.getOrderList(map);
        if (orderList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        return orderList;
    }

    @Override
    public List<Order> getOrderAllList(Map<String, Object> map) throws BusinessException {
        // 转化时间格式的字符串
        // 获取起始时间字符串的值
        Object from1 = map.get("from");
        // 获取终止时间字符串的值
        Object to1 = map.get("to");
        // 判断起始时间的字符串是否为空
        if (from1 != null) {
            String from = from1.toString();
            // 不为空时转化字符串为Timestamp格式
            Timestamp fromTime = Timestamp.valueOf(from);
            // 将新的timestamp格式的数据放入map中
            map.put("from", fromTime);
        } else {
            map.put("from", null);
        }
        // 判断终止时间的字符串是否为空
        if (to1 != null) {
            String to = to1.toString();
            // 不为空时转化字符串为Timestamp格式
            Timestamp toTime = Timestamp.valueOf(to);
            // 将新的timestamp格式的数据放入map中
            map.put("to", toTime);
        } else {
            map.put("to", null);
        }
        // 处理分页--当前端传递的消息中size==0时,表示全查询
        // limit (page - 1)*size,size
        // 获取map中的分页信息
        String page = map.get("page").toString();
        //---------------
        String size = map.get("size").toString();
        // 如果map中page和size为空,则给page和size给予默认值
        int page1 = 1;
        // 将处理之后的数据放入map中
        map.put("page", page1);
        map.put("size", 0);
        // 调用获取 订单 列表
        List<Order> orderList = orderMapper.getOrderList(map);
        if (orderList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        return orderList;
    }

    @Override
    public List<OrderVo> getReturnCarList() throws BusinessException {
        // 调用获取 还车 列表
        List<OrderVo> returnCarList = orderMapper.getReturnCarList();
        if (returnCarList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        return returnCarList;
    }

    @Override
    public void deleteBatchOrder(List<Integer> deleteIds) {
        orderMapper.deleteBatchOrder(deleteIds);
    }

    @Override
    public List<OrderVo> exportBatchOrderList(List<Integer> exportIds) throws BusinessException {
        // 对参数进行判断
        if (exportIds.size() == 0) {
            throw new BusinessException(ExceptionCode.NOT_CHOOSE);
        }
        // 调用获取 订单Vo 列表
        List<OrderVo> orderVos = orderMapper.exportBatchOrderList(exportIds);
        if (orderVos.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        return orderVos;
    }

    @Override
    public List<OrderVo> getThreeOrderList() throws BusinessException {
        // 调用获取 订单Vo 列表
        List<OrderVo> threeOrderList = orderMapper.getThreeOrderList();
        if (threeOrderList.size() == 0) {
            throw new BusinessException(ExceptionCode.NO_SUCH);
        }
        return threeOrderList;
    }

    @Override
    public Order getOrderAll(String orderNum) {
        return orderMapper.getOrderAll(orderNum);
    }
}
